The phrase "bad-faith contributions" may be too strong, as it implies intentional malice. Many contributors using unsupervised AI tools may not realize the impact rather than acting in bad faith. Consider rephrasing to "low-quality or inappropriate contributions" to focus on the outcome rather than attributing intent.

The reference to "OpenClaw" appears to be a specific tool name. If this is meant to be a general term or if the tool name is incorrect, this should be clarified. If it's a real tool, consider whether naming specific tools in the Context subsection could become outdated or be perceived as targeting specific products.

Disagree, using OpenClaw as an example is useful.

Also there's an assymetry at play. Someone is prioritizing what we review without making an equivalent time or money investment. When a contributor think an issue is important enough to work on it and does, they effectively gives time to influence the priorization of the project. Most github sponsor pay tier include a 'prioritize this issue', generally an expansive tier intended for companies. Those agentic contribution expect to prioritize what maintainers work on at near zero cost for them.

Let's assume good faith ? (I suppose the intent is still to help, although I already encountered AI researchers that were just trying their creation in the wild using my time, those were not deterred by common decency and are not going to be deterred by the contributing.rst)

It'd be useful to get the prompts too.

based on how i observe agent tool usage and refinement that would be a mess

The original prompt would be very useful to have indeed. Often more useful than the result tbh. And it would show the actual amount of effort that went into it which would be a great deterrent against low effort ai driven fix.

This is not something you can rightfully expect contributors to record and does not match with the wide variety of ways people use modern tooling. It also conveys zero information.

These checkboxes can only be used to discriminate against contributions based on non-technical merits. Meaning people will naturally self-correct towards not disclosing because of the discriminatory attitude the existence of this text implies.

I say this out of compassion. This will alienate contributors by trying to claim that how a change was made and by whom is more important than the substance.

Focus on the respectful interactions, outcomes, and code quality needs. Knowing what text editor or IDE someone used is 100% irrelevant.

See the first paragraph from https://devguide.python.org/getting-started/generative-ai/ for example.

(From a geeky agentic model use learning perspective: While I enjoy seeing prompts and sessions along with the exact specific details of which model version was used via what, that is an entirely unreasonable ask of people. It is not something that belongs in any project's policy.)

This is not something you can rightfully expect contributors to record and does not match with the wide variety of ways people use modern tooling. It also conveys zero information.

I kind agree with this; I almost never get something done using a AI coding tool with just one prompt, often I end up using more than one prompt. Are contributors expected to post the entire conversation in their PR description? This is not practical, and probably brings almost no value, that I can see at least.

In the future, it is very likely that every contribution will have some AI involved, ranging from basic AI features (like smarter auto complete) from full blown coding agent. Requiring users to disclose this fact does not seem very useful, TBH.

The intent from this policy, from my POV, is to stop/prevent fully automated contributions, where at no point a human was involved prior to the PR being submitted. I have no problem people using AI tools to contribute, and I don't think we need to require them to disclose using those tools -- both from not bringing much value as well as not being practical.

currently theres no good way to track prompts and intents

sometimes i literally prompt by pasting issue link into the chat, sometimes i write down 5-10 paragraphs of detail and run a planning rounds with q&a by the agent - and then on top of that sometimes i do re-basing and squashing with the agent - currently im not aware of a way to propperly trace that in a sensible manner

also sometimes i do swear at the llms when they do something extra messy - and like with a good old hammer or saw or screwdriver i like that the tool keeps no memory of my language there

Indeed!

All the more reason disclosing that an LLM was used is not useful. Important thing is that there's a human reviewing and understanding the code before it is even submitted.

This may have come out of the policy we're iterating on over in pip-tools, where I believe I was the one to suggest asking how tools were used.

My goal in such an inclusion is not that I particularly care what exact inputs were given to an LLM -- in fact, I really, really don't care, any more than I care what brand of pliers my electrician uses¹ -- but rather that I want to understand what the contributor is even trying to do.

The intent behind changes is significant. If it's not aligned with the actual changes in the diff -- e.g., an apparently unrelated test is modified -- it prompts us to ask why those extra changes were necessary.

So I stand by the ethos behind the suggestion: understanding contributor intent. But clearly, based on the responses here, we'll have to get at that information in a different way.

I personally don't think disclosing that an Agent was used is particularly useful, and also very hard to policy/enforce.

How about we instead focus on the main issue, that fully automatic contributions are not accepted?

Perhaps focus on the "unsupervised" aspect:

Suggestion 1: I would switch the order here, with the "Purely agentic contributions" section appearing first, because I believe this is the main problem we want to address.

Suggestion 2: As I mentioned earlier, I don't think we need to enforce crediting AI agents as co-authors, as this does not bring much value (IMHO) and is hard/impossible to enforce.

In that subject, one important thing is that using an agent as co-author cannot be an excuse for lack of understanding or poorly written code -- it does not matter if an agent wrote the code, if you pushed it, you are responsible for it. You cannot later say "oh I don't know why the code was written that way, it was not written by me, but by Claude". You need to take ownership of the code produced by the Agent, as ultimately the code is your responsibility.

This point written above express this well:

Every contribution must demonstrate that a human has reviewed,
understood, and taken responsibility for the changes.

"taken responsibility" here is key.